/**
 * 综合实例：数据维护(四合一)
 *
 * @author XiongChun
 * @since 2010-11-20
 */
Ext.onReady(function(){
	var delArray = [];
    var qForm = new Ext.form.FormPanel({
        region: 'north',
        title: '<span class="commoncss">查询条件<span>',
        collapsible: true,
        border: true,
        labelWidth: 50, // 标签宽度
        // frame : true, //是否渲染表单面板背景色
        labelAlign: 'right', // 标签对齐方式
        bodyStyle: 'padding:3 5 0', // 表单元素和表单面板的边距
        buttonAlign: 'center',
        height: 120,
        items: [{
            layout: 'column',
            border: false,
            items: [{
                columnWidth: .25,
                layout: 'form',
                labelWidth: 60, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    fieldLabel: '订单编号',
                    name: 'ddbh',
                    id: 'ddbh',
                    anchor: '100%'
                }]
            },  {
                columnWidth: .25,
                layout: 'form',
                labelWidth: 60, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [new Ext.form.ComboBox({
                    hiddenName: 'zfzt',
                    fieldLabel: '作废状态',
                    emptyText: '请选择',
                    triggerAction: 'all',
                    store: new Ext.data.SimpleStore({
                        fields: ['name', 'code'],
                        data: [['作废', '1'], ['使用', '0']]
                    }),
                    displayField: 'name',
                    valueField: 'code',
                    mode: 'local',
                    forceSelection: false, // 选中内容必须为下拉列表的子项
                    editable: false,
                    typeAhead: true,
                    // value:'0002',
                    resizable: true,
                    anchor: '100%'
                })]
            },{
                columnWidth: .20,
                layout: 'form',
                labelWidth: 100, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    xtype : 'datefield',
                    fieldLabel : '订单开始时间', // 标签
                    name : 'datebegin', // name:后台根据此name属性取值 
                    format:'Y-m-d', //日期格式化
                    value:new Date(),
                    anchor : '100%' // 宽度百分比
                }]
            },{
                columnWidth: .20,
                layout: 'form',
                labelWidth: 100, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    xtype : 'datefield',
                    fieldLabel : '订单结束时间', // 标签
                    name : 'dataend', // name:后台根据此name属性取值 
                    format:'Y-m-d', //日期格式化
                    value:new Date(),
                    anchor : '100%' // 宽度百分比
                }]
            }]
        }],
        buttons: [{
            text: '查询',
            iconCls: 'previewIcon',
            handler: function(){
                Ext.getCmp('tbi_edit').disable();
                Ext.getCmp('tbi_del').disable();
                Ext.getCmp('tbi_auid').disable();
                Ext.getCmp('tbi_bh').disable();
                Ext.getCmp('tbi_wc').disable();
                queryOrderDatas();
            }
        }, {
            text: '打印',
            id: 'id_btn_print',
            iconCls: 'printerIcon',
            handler: function(){
                printCatalog1();
            }
        }, {
            text: '重置',
            iconCls: 'tbar_synchronizeIcon',
            handler: function(){
                qForm.getForm().reset();
            }
        }]
    });
    
    // 定义自动当前页行号
    var rownum = new Ext.grid.RowNumberer({
        header: 'NO',
        width: 28
    });
    
    // 定义列模型
    var cm = new Ext.grid.ColumnModel([rownum, {
        header: '订单编号', // 列标题
        dataIndex: 'ordernos', // 数据索引:和Store模型对应
        sortable: true
        // 是否可排序
    }, {
        header: '下单学校', // 列标题
        dataIndex: 'orders', // 数据索引:和Store模型对应
        sortable: true// 是否可排序
    }, {
        header: '总金额',
        dataIndex: 'totalp',
        sortable: true,
        // 列宽
    }, {
        header: '实际金额',
        dataIndex: 'totals',
        sortable: true
    }, {
        header: '操作状态',
        dataIndex: 'operstatus'
    }, {
        header: '是否删除',
        dataIndex: 'isdel',
		width : 60
    },{
        header: '操作人员',
        dataIndex: 'opernames'
    }, {
        header: '操作时间',
        dataIndex: 'updatetime'
    }]);
    
    /**
     * 数据存储
     */
    var store = new Ext.data.Store({
        // 获取数据的方式
        proxy: new Ext.data.HttpProxy({
            url: 'order.ered?reqCode=queryOrders'
        }),
        reader: new Ext.data.JsonReader({
            totalProperty: 'TOTALCOUNT', // 记录总数
            root: 'ROOT' // Json中的列表数据根节点
        }, [{
            name: 'ordernos' // Json中的属性Key值
        }, {
            name: 'orders'
        }, {
            name: 'totalp'
        }, {
            name: 'totals'
        }, {
            name: 'operstatus'
        }, {
            name: 'isdel'
        }, {
            name: 'opernames'
        },{
            name: 'updatetime'
        }])
    });
    
    /**
     * 翻页排序时候的参数传递
     */
    // 翻页排序时带上查询条件
    store.on('beforeload', function(){
        this.baseParams = qForm.getForm().getValues();
    });
    // 每页显示条数下拉选择框
    var pagesize_combo = new Ext.form.ComboBox({
        name: 'pagesize',
        triggerAction: 'all',
        mode: 'local',
        store: new Ext.data.ArrayStore({
            fields: ['value', 'text'],
            data: [[10, '10条/页'], [20, '20条/页'], [50, '50条/页'], [100, '100条/页'], [250, '250条/页'], [500, '500条/页']]
        }),
        valueField: 'value',
        displayField: 'text',
        value: '20',
        editable: false,
        width: 85
    });
    var number = parseInt(pagesize_combo.getValue());
    // 改变每页显示条数reload数据
    pagesize_combo.on("select", function(comboBox){
        bbar.pageSize = parseInt(comboBox.getValue());
        number = parseInt(comboBox.getValue());
        store.reload({
            params: {
                start: 0,
                limit: bbar.pageSize
            }
        });
    });
    
    // 分页工具栏
    var bbar = new Ext.PagingToolbar({
        pageSize: number,
        store: store,
        displayInfo: true,
        displayMsg: '显示{0}条到{1}条,共{2}条',
        plugins: new Ext.ux.ProgressBarPager(), // 分页进度条
        emptyMsg: "没有符合条件的记录",
        items: ['-', '&nbsp;&nbsp;', pagesize_combo]
    });
    
    // 表格工具栏
    var tbar = new Ext.Toolbar({
        items: [{
            text: '新增',
            iconCls: 'addIcon',
            id: 'id_tbi_add',
            handler: function(){
                addCatalogItem();
            }
        }, {
            text: '修改',
            id: 'tbi_edit',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                updateCatalogItem();
            }
        }, {
            text: '删除',
            id: 'tbi_del',
            iconCls: 'deleteIcon',
            disabled: true,
            handler: function(){
                deleteCatalogItem();
            }
        },{
            text: '审核',
            id: 'tbi_auid',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                auid('1');
            }
        },{
            text: '驳回',
            id: 'tbi_bh',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                auid('2');
            }
        },{
            text: '完成',
            id: 'tbi_wc',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                auid('3');
            }
        }, '->', {
            text: '刷新',
            iconCls: 'arrow_refreshIcon',
            handler: function(){
                store.reload();
            }
        }]
    });
    
    // 表格实例
    var grid = new Ext.grid.GridPanel({
        // 表格面板标题,默认为粗体，我不喜欢粗体，这里设置样式将其格式为正常字体
        title: '<span class="commoncss">厂商信息列表</span>',
        height: 500,
        id: 'id_grid_sfxm',
        autoScroll: true,
        frame: true,
        region: 'center', // 和VIEWPORT布局模型对应，充当center区域布局
        store: store, // 数据存储
        stripeRows: true, // 斑马线
        cm: cm, // 列模型
        tbar: tbar, // 表格工具栏
        bbar: bbar,// 分页工具栏
        viewConfig: {            // 不产横向生滚动条, 各列自动扩展自动压缩, 适用于列数比较少的情况
            // forceFit : true
        },
        loadMask: {
            msg: '正在加载表格数据,请稍等...'
        }
    });
    
    // 监听行选中事件
    grid.on('rowclick', function(pGrid, rowIndex, event){
		alert("dd");
        Ext.getCmp('tbi_edit').enable();
        Ext.getCmp('tbi_del').enable();
        Ext.getCmp('tbi_auid').enable();
        Ext.getCmp('tbi_bh').enable();
        Ext.getCmp('tbi_wc').enable();
    });
    
    grid.on('rowdblclick', function(grid, rowIndex, event){
        updateCatalogItem();
    });
    
	/**
     * 查询项目列表
     */
    function queryOrderDatas(){
        var params = qForm.getForm().getValues();
        params.start = 0;
        params.limit = bbar.pageSize;
        store.load({
            params: params
        });
    }
	    
    // 布局
    // 如果把form作为center区域的话,其Height属性将失效。
    var viewport = new Ext.Viewport({
        layout: 'border',
        items: [qForm, grid]
    });
    
    //+++++++++++++++++++++++++++++++++++++++++++++++++++
    var goodStore = new Ext.data.Store({
                        proxy : new Ext.data.HttpProxy({
                                    url : 'order.ered?reqCode=queryGoods'
                                }),
                        reader : new Ext.data.JsonReader({}, [{
                                            name : 'value'
                                        }, {
                                            name : 'text'
                                        }]),
                        baseParams : {
                            //areacode : '53'
                        },
                        listeners : {
                            // 设置远程数据源下拉选择框的初始值
                            'load' : function(obj) {
                                //areaCombo.setValue('530101');
                            }
                        }
                    });

            goodStore.load(); // 如果mode : 'local',时候才需要手动load();
    var goodCombo = new Ext.form.ComboBox({
                hiddenName : 'good',
                fieldLabel : '选择道具',
                emptyText : '请选择...',
                triggerAction : 'all',
                store : goodStore,
                displayField : 'text',
                valueField : 'value',
                loadingText : '正在加载数据...',
                mode : 'local', // 数据会自动读取,如果设置为local又调用了store.load()则会读取2次；也可以将其设置为local，然后通过store.load()方法来读取
                allowBlank : true,
                forceSelection : false,
                editable : true,
                typeAhead : true,
                plugins:[new QM.plugin.PinyinFilter],
                // value : '530101',
                anchor : '100%'
                    // 设置远程数据源下拉选择框的初始值(此延时方法不好，使用上面的监听areaStore的load事件的方法)
                    /*
                     * listeners : { 'render' : function(obj) {
                     * areaStore.load(); window.setTimeout(function() {
                     * obj.setValue('530101'); }, 200) } }
                     */
                });
    /**
     * 录入页面
     */
    var myForm = new Ext.form.FormPanel({
        region: 'north',
        //title: '<span class="commoncss">订单信息<span>',
        collapsible: true,
        border: true,
        labelWidth: 60, // 标签宽度
        //labelWidth: 60, // 标签宽度
        labelAlign: 'right', // 标签对齐方式
        bodyStyle: 'padding:3 5 0', // 表单元素和表单面板的边距
        buttonAlign: 'center',
        height: 20,
        items: [{
            layout: 'column',
            border: false,
            items: [{
                columnWidth: .30,
                layout: 'form',
                labelWidth: 60, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    fieldLabel: '订单编号',
                    name: 'ordernos',
                    id:'ordernos',
                    maxLength: 30,
                    readOnly: true,
                    emptyText: '单号自动生成',
                    anchor: '100%'
                }, {
                    fieldLabel: '下单原因',
                    name: 'orderre',
                    xtype: 'textarea',
                    maxLength: 100,
                    anchor: '100%'
                }]
            }, {
                columnWidth: .40,
                layout: 'form',
                //labelWidth: 60, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    fieldLabel: '下单学校', // 标签
                    name: 'orders', // name:后台根据此name属性取值
                    maxLength: 20, // 可输入的最大文本长度,不区分中英文字符
                    readOnly: true,
                    anchor: '100%'// 宽度百分比
                }, {
                    fieldLabel: '驳回理由',
                    xtype: 'textarea',
                    maxLength: 100,
                    anchor: '100%'
                }]
            }]
        }]
    });
    
    // 定义自动当前页行号
    var rownum2 = new Ext.grid.RowNumberer({
        header: 'NO',
        width: 28
    });
    
    //选中时间联动
        goodCombo.on('select', function() {
        // 提交到后台处理
            Ext.Ajax.request({
                url: 'order.ered?reqCode=queryGood',
                success: function(response){ // 回调函数有1个参数
                var resultArray = Ext.util.JSON.decode(response.responseText);
                var sm = grid2.getSelectionModel();
                //alert(sm);
                var cell = sm.getSelectedCell();
                if (Ext.isEmpty(cell)) {
                    Ext.Msg.alert('提示', '你没有选中行');
                }
                var record = store2.getAt(cell[0]);
                record.set('goodname', resultArray['goodname'])
                record.set('goodunit', resultArray['goodunit'])
                record.set('goodprice', resultArray['price'])
                record.set('gooddis', resultArray['discount'])
                },
                failure: function(response){
                    Ext.MessageBox.alert('提示', '物品数据不存在');
                },
                params: {
                    // 系列化为Json资料格式传入后台处理
                    goodnos: this.getValue()
                }
            });
        });
    
    // 定义列模型
    var cm2 = new Ext.grid.ColumnModel([rownum2, {
        header: '明细单号', // 列标题
        dataIndex: 'detailno', // 数据索引:和Store模型对应
        emptyMsg: '自动生成',
        sortable: true
        // 是否可排序
    }, {
        header: '商品号',
        dataIndex: 'goodno',
        sortable: true,
        editor:goodCombo,
    
    }, {
        header: '商品名称',
        dataIndex: 'goodname',
    }, {
        header: '商品单位',
        dataIndex: 'goodunit',
        renderer : UNITRender,
        editor : new Ext.grid.GridEditor(new Ext.form.ComboBox({
                    store : UNITStore,
                    mode : 'local',
                    triggerAction : 'all',
                    valueField : 'value',
                    displayField : 'text',
                    allowBlank : false,
                    forceSelection : true,
                    typeAhead : true
                })),
        width : 60
    }, {
        header: '商品单价',
        dataIndex: 'goodprice',
        emptyText: '0',
        width: 60
    }, {
        header: '商品折扣',
        dataIndex: 'gooddis',
        width: 60
    }, {
        header: '下单数量',
        dataIndex: 'ordernum',
        emptyMsg:'1',
        enableKeyEvents : true,
        
        editor: new Ext.grid.GridEditor(new Ext.form.NumberField({
            // 只对原有数据编辑有效,对新增一行的场景无效
            //emptyText: 0,
            maxValue: 100000,
            minValue : 1,
            decimalPrecision: 0,// 小数精度
            allowBlank: false,
            listeners : {
                blur: function(field, e) {
                var sm = grid2.getSelectionModel();
                //alert(sm);
                var cell = sm.getSelectedCell();
                if (Ext.isEmpty(cell)) {
                    Ext.Msg.alert('提示', '你没有选中行');
                }
                var record = store2.getAt(cell[0]);
                var price = record.get('goodprice');
                var dis = record.get('gooddis');
                record.set('totalprice', field.getValue() * price *dis);
                //alert(field.getValue() * price);
                countAll();
                }
            },
        })),
        width: 60
    },{
        header: '合计',
        dataIndex: 'totalprice',
        width: 60
    }
    ]);
    
    /**
     * 数据存储
     */
    var store2 = new Ext.data.Store({
        pruneModifiedRecords: true,
        // 获取数据的方式
        proxy: new Ext.data.HttpProxy({
            url: 'order.ered?reqCode=queryDetail'
        }),
        // 数据读取器
        reader: new Ext.data.JsonReader({
            totalProperty: 'TOTALCOUNT', // 记录总数
            root: 'ROOT' // Json中的列表数据根节点
        }, [{
            name: 'detailno' // Json中的属性Key值
        },{
            name: 'goodname' // Json中的属性Key值
        },{
            name: 'goodunit' // Json中的属性Key值
        },{
            name: 'goodprice' // Json中的属性Key值
        },{
            name: 'gooddis' // Json中的属性Key值
        }, {
            name: 'ordernum'
        }, {
            name: 'goodno'
        },{
            name: 'totalprice'
        }])
    });
    
    // 定义一个Record
    var MyRecord = Ext.data.Record.create([
    {
        name: 'detailno',
        type: 'string'
    }, {
        name: 'goodno',
        type: 'string'
    },{
        name: 'goodname',
        type: 'string'
    },{
        name: 'goodunit',
        type: 'string'
    },{
        name: 'price',
        type: 'double'
    },{
        name: 'discount',
        type: 'double'
    }, {
        name: 'ordernum',
        type: 'int'
    },{
        name: 'totalprice',
        type: 'int'
    }]);
    
    
    // 表格工具栏
    var tbar2 = new Ext.Toolbar({
        items: [{
            text:'',
            xtype: 'button',
            handleMouseEvents :false,
            readOnly:true,
            width: 270,
        }, '-', {
            text: '新增一行',
            iconCls: 'addIcon',
            handler: function(){
                var row = new MyRecord({});
                row.set('goodprice', 0); // 赋初值
                row.set('detailno', '自动生成'); // 赋初值
                row.set('gooddis',1);
                row.set('totalprice',0);
                grid2.stopEditing();
                store2.insert(0, row);
                grid2.startEditing(0, 2);
            }
        }, {
            text: '删除一行',
            iconCls: 'deleteIcon',
            handler: function(){
                var sm = grid2.getSelectionModel();
                var cell = sm.getSelectedCell();
                if (Ext.isEmpty(cell)) {
                    Ext.Msg.alert('提示', '你没有选中行');
                }
                var record = store2.getAt(cell[0]);
                //删除的订单号放入array
                if(''!= record.get('detailno') && '自动生成' != record.get('detailno')){
                    delArray.push(record.get('detailno'));
                }
                store2.remove(record);
            }
        }, {
            text: '保存',
            iconCls: 'acceptIcon',
            handler: function(){
                saveRow();
            }
        },'-',{
            text:'合计',
            xtype: 'button',
            id: 'totalmoney',
            name: 'totalmoney',
            handleMouseEvents :false,
            emptyText: '订单合计数量',
            readOnly:true,
            width: 150,
        }]
    });
    
    // 表格实例
    var grid2 = new Ext.grid.EditorGridPanel({
        // 表格面板标题,默认为粗体，我不喜欢粗体，这里设置样式将其格式为正常字体
        title: '<span class="commoncss">订单明细</span>',
        height: 500,
        id: 'id_grid_grid2',
        autoScroll: true,
        //columnWidth: .90,
        frame: true,
        region: 'center', // 和VIEWPORT布局模型对应，充当center区域布局
        store: store2, // 数据存储
        //stripeRows : true, // 斑马线
        cm: cm2, // 列模型
        tbar: tbar2, // 表格工具栏
        //bbar : bbar2,// 分页工具栏 
        clicksToEdit: 1, // 单击、双击进入编辑状态
        viewConfig: {
            // 不产横向生滚动条, 各列自动扩展自动压缩, 适用于列数比较少的情况
            forceFit: false
        },
        loadMask: {
            msg: '正在加载表格数据,请稍等...'
        }
    });
    
    
    // 页面初始自动查询数据
    //store2.load();
    
    // 布局模型
    // var viewport = new Ext.Viewport({
        // layout: 'border',
        // items: [myForm, grid2]
    // });
    
    // 查询表格数据
    function queryCatalogItem(){
        store2.load({
            params: {
                start: 0,
                //limit : bbar2.pageSize,
                orderno: Ext.getCmp('ordernos').getValue()
            }
        });
    }
    
    //合计金额
    function countAll(){
         var m = store2.sum('totalprice');
         //alert(m);
         Ext.getCmp('totalmoney').setText('合计：'+m);
    }
    
    
    
    // 保存
    function saveRow(){
        var m = store2.modified.slice(0); // 获取修改过的record数组对象
        //if (Ext.isEmpty(m)) {
         //   Ext.MessageBox.alert('提示', '没有数据需要保存!');
         //   return;
        //}
        if (!validateEditGrid(m, 'goodno')) {
            Ext.Msg.alert('提示', '商品号名称字段数据校验不合法,请重新输入!', function(){
                grid2.startEditing(0, 2);
            });
            return;
        }
        if (!validateEditGrid(m, 'ordernum')) {
                    Ext.Msg.alert('提示', '订单数量不合法,请重新输入!', function() {
                                grid.startEditing(0, 7);
                            });
                    return;
                }
        var jsonArray = [];
        // 将record数组对象转换为简单Json数组对象
        Ext.each(m, function(item){
            jsonArray.push(item.data);
        });
        // 提交到后台处理
        Ext.Ajax.request({
            url: 'order.ered?reqCode=saveOrder',
            success: function(response){ // 回调函数有1个参数
                var resultArray = Ext.util.JSON.decode(response.responseText);
                Ext.getCmp('ordernos').setValue(resultArray['ordernos']);
                Ext.Msg.alert('提示', resultArray['result']);
                 store2.load({
                    params: {
                        start: 0,
                        //limit : bbar2.pageSize,
                        ordernos: Ext.getCmp('ordernos').getValue()
            }
        });
            },
            failure: function(response){
                Ext.MessageBox.alert('提示', '数据保存失败');
            },
            params: {
                deldata : Ext.encode(delArray),
                // 系列化为Json资料格式传入后台处理
                detailData: Ext.encode(jsonArray)
            }
        });
    }
    
    // 检查新增行的可编辑单元格数据合法性
    function validateEditGrid(m, colName){
        for (var i = 0; i < m.length; i++) {
            var record = m[i];
            var rowIndex = store2.indexOfId(record.id);
            var value = record.get(colName);
            if (Ext.isEmpty(value)) {
                // Ext.Msg.alert('提示', '数据校验不合法');
                return false;
            }
            var colIndex = cm2.findColumnIndex(colName);
            var editor = cm2.getCellEditor(colIndex).field;
            if (!editor.validateValue(value)) {
                // Ext.Msg.alert('提示', '数据校验不合法');
                return false;
            }
        }
        return true;
    }
    
    /**
     * 添加物品新界面
     */
   var firstWindow = new Ext.Window({
        title: '<span class="commoncss">录入产品信息<span>', // 窗口标题
        layout: 'fit', // 设置窗口布局模式
        width: 800, // 窗口宽度
        height: 440, // 窗口高度
        closable: false, // 是否可关闭
        collapsible: true, // 是否可收缩
        maximizable: true, // 设置是否可以最大化
        border: false, // 边框线设置
        constrain: true, // 设置窗口是否可以溢出父容器
        autoScroll: true,
        animateTarget: Ext.getBody(),
        pageY: 20, // 页面定位Y坐标
        pageX: document.body.clientWidth / 2 - 800 / 2, // 页面定位X坐标
        items: [myForm,grid2], // 嵌入的表单面板
        buttons: [{
            text: '生成',
            iconCls: 'acceptIcon',
            handler: function(){
                submitTheFormNew();
            }
        }, {
            text: '重置',
            iconCls: 'tbar_synchronizeIcon',
            handler: function(){
                myForm.getForm().reset();
            }
        }, {
            text: '关闭',
            iconCls: 'deleteIcon',
            handler: function(){
                firstWindow.hide();
                queryOrderDatas();
            }
        }]
    });
    /**
     * 新增项目
     */
    function addCatalogItem(){
        firstWindow.show(); // 显示窗口
    }
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //更新界面
    //************************************************************
     var goodStore3 = new Ext.data.Store({
                        proxy : new Ext.data.HttpProxy({
                                    url : 'order.ered?reqCode=queryGoods'
                                }),
                        reader : new Ext.data.JsonReader({}, [{
                                            name : 'value'
                                        }, {
                                            name : 'text'
                                        }]),
                        baseParams : {
                            //areacode : '53'
                        },
                        listeners : {
                            // 设置远程数据源下拉选择框的初始值
                            'load' : function(obj) {
                                //areaCombo.setValue('530101');
                            }
                        }
                    });

            goodStore3.load(); // 如果mode : 'local',时候才需要手动load();
    var goodCombo3 = new Ext.form.ComboBox({
                hiddenName : 'good',
                fieldLabel : '选择道具',
                emptyText : '请选择...',
                triggerAction : 'all',
                store : goodStore3,
                displayField : 'text',
                valueField : 'value',
                loadingText : '正在加载数据...',
                mode : 'local', // 数据会自动读取,如果设置为local又调用了store.load()则会读取2次；也可以将其设置为local，然后通过store.load()方法来读取
                allowBlank : true,
                forceSelection : false,
                editable : true,
                typeAhead : true,
                plugins:[new QM.plugin.PinyinFilter],
                // value : '530101',
                anchor : '100%'
                    // 设置远程数据源下拉选择框的初始值(此延时方法不好，使用上面的监听areaStore的load事件的方法)
                    /*
                     * listeners : { 'render' : function(obj) {
                     * areaStore.load(); window.setTimeout(function() {
                     * obj.setValue('530101'); }, 200) } }
                     */
                });
    /**
     * 录入页面
     */
    var updateForm = new Ext.form.FormPanel({
        region: 'north',
        //title: '<span class="commoncss">订单信息<span>',
        collapsible: true,
        border: true,
        labelWidth: 60, // 标签宽度
        //labelWidth: 60, // 标签宽度
        labelAlign: 'right', // 标签对齐方式
        bodyStyle: 'padding:3 5 0', // 表单元素和表单面板的边距
        buttonAlign: 'center',
        height: 20,
        items: [{
            layout: 'column',
            border: false,
            items: [{
                columnWidth: .30,
                layout: 'form',
                labelWidth: 60, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    fieldLabel: '订单编号',
                    name: 'ordernos',
                    id:'updateno',
                    maxLength: 30,
                    readOnly: true,
                    emptyText: '单号自动生成',
                    anchor: '100%'
                }, {
                    fieldLabel: '下单原因',
                    name: 'orderre',
                    xtype: 'textarea',
                    maxLength: 100,
                    anchor: '100%'
                }]
            }, {
                columnWidth: .40,
                layout: 'form',
                //labelWidth: 60, // 标签宽度
                defaultType: 'textfield',
                border: false,
                items: [{
                    fieldLabel: '下单学校', // 标签
                    name: 'orders', // name:后台根据此name属性取值
                    maxLength: 20, // 可输入的最大文本长度,不区分中英文字符
                    readOnly: true,
                    anchor: '100%'// 宽度百分比
                }, {
                    fieldLabel: '驳回理由',
                    xtype: 'textarea',
                    maxLength: 100,
                    anchor: '100%'
                }]
            }]
        }]
    });
    
    // 定义自动当前页行号
    var rownum3 = new Ext.grid.RowNumberer({
        header: 'NO',
        width: 28
    });
    
    //选中时间联动
        goodCombo3.on('select', function() {
        // 提交到后台处理
            Ext.Ajax.request({
                url: 'order.ered?reqCode=queryGood',
                success: function(response){ // 回调函数有1个参数
                var resultArray = Ext.util.JSON.decode(response.responseText);
                var sm = grid3.getSelectionModel();
                //alert(sm);
                var cell = sm.getSelectedCell();
                if (Ext.isEmpty(cell)) {
                    Ext.Msg.alert('提示', '你没有选中行');
                }
                var record = store3.getAt(cell[0]);
                record.set('goodname', resultArray['goodname'])
                record.set('goodunit', resultArray['goodunit'])
                record.set('goodprice', resultArray['price'])
                record.set('gooddis', resultArray['discount'])
                },
                failure: function(response){
                    Ext.MessageBox.alert('提示', '物品数据不存在');
                },
                params: {
                    // 系列化为Json资料格式传入后台处理
                    goodnos: this.getValue()
                }
            });
        });
    
    // 定义列模型
    var cm3 = new Ext.grid.ColumnModel([rownum3, {
        header: '明细单号', // 列标题
        dataIndex: 'detailno', // 数据索引:和Store模型对应
        emptyMsg: '自动生成',
        sortable: true
        // 是否可排序
    }, {
        header: '商品号',
        dataIndex: 'goodno',
        sortable: true,
        editor:goodCombo3,
    
    }, {
        header: '商品名称',
        dataIndex: 'goodname',
    }, {
        header: '商品单位',
        dataIndex: 'goodunit',
        renderer : UNITRender,
        editor : new Ext.grid.GridEditor(new Ext.form.ComboBox({
                    store : UNITStore,
                    mode : 'local',
                    triggerAction : 'all',
                    valueField : 'value',
                    displayField : 'text',
                    allowBlank : false,
                    forceSelection : true,
                    typeAhead : true
                })),
        width : 60
    }, {
        header: '商品单价',
        dataIndex: 'goodprice',
        emptyText: '0',
        width: 60
    }, {
        header: '商品折扣',
        dataIndex: 'gooddis',
        width: 60
    }, {
        header: '下单数量',
        dataIndex: 'ordernum',
        emptyMsg:'1',
        enableKeyEvents : true,
        
        editor: new Ext.grid.GridEditor(new Ext.form.NumberField({
            // 只对原有数据编辑有效,对新增一行的场景无效
            //emptyText: 0,
            maxValue: 100000,
            minValue : 1,
            decimalPrecision: 0,// 小数精度
            allowBlank: false,
            listeners : {
                blur: function(field, e) {
                var sm = grid3.getSelectionModel();
                //alert(sm);
                var cell = sm.getSelectedCell();
                if (Ext.isEmpty(cell)) {
                    Ext.Msg.alert('提示', '你没有选中行');
                }
                var record = store3.getAt(cell[0]);
                var price = record.get('goodprice');
                var dis = record.get('gooddis');
                record.set('totalprice', field.getValue() * price *dis);
                //alert(field.getValue() * price);
                countAll();
                }
            },
        })),
        width: 60
    },{
        header: '合计',
        dataIndex: 'totalprice',
        width: 60
    }
    ]);
    
    /**
     * 数据存储
     */
    var store3 = new Ext.data.Store({
        pruneModifiedRecords: true,
        // 获取数据的方式
        proxy: new Ext.data.HttpProxy({
            url: 'order.ered?reqCode=queryDetail'
        }),
        // 数据读取器
        reader: new Ext.data.JsonReader({
            totalProperty: 'TOTALCOUNT', // 记录总数
            root: 'ROOT' // Json中的列表数据根节点
        }, [{
            name: 'detailno' // Json中的属性Key值
        },{
            name: 'goodname' // Json中的属性Key值
        },{
            name: 'goodunit' // Json中的属性Key值
        },{
            name: 'goodprice' // Json中的属性Key值
        },{
            name: 'gooddis' // Json中的属性Key值
        }, {
            name: 'ordernum'
        }, {
            name: 'goodno'
        },{
            name: 'totalprice'
        }])
    });
    
    // 定义一个Record
    var MyRecord3 = Ext.data.Record.create([
    {
        name: 'detailno',
        type: 'string'
    }, {
        name: 'goodno',
        type: 'string'
    },{
        name: 'goodname',
        type: 'string'
    },{
        name: 'goodunit',
        type: 'string'
    },{
        name: 'price',
        type: 'double'
    },{
        name: 'discount',
        type: 'double'
    }, {
        name: 'ordernum',
        type: 'int'
    },{
        name: 'totalprice',
        type: 'int'
    }]);
    
    
    // 表格工具栏
    var tbar3 = new Ext.Toolbar({
        items: [{
            text:'',
            xtype: 'button',
            handleMouseEvents :false,
            readOnly:true,
            width: 180,
        }, '-', {
            text: '新增一行',
            iconCls: 'addIcon',
            handler: function(){
                var row = new MyRecord3({});
                row.set('goodprice', 0); // 赋初值
                row.set('detailno', '自动生成'); // 赋初值
                row.set('gooddis',1);
                row.set('totalprice',0);
                grid3.stopEditing();
                store3.insert(0, row);
                grid3.startEditing(0, 2);
            }
        }, {
            text: '删除一行',
            iconCls: 'deleteIcon',
            handler: function(){
                var sm = grid3.getSelectionModel();
                var cell = sm.getSelectedCell();
                if (Ext.isEmpty(cell)) {
                    Ext.Msg.alert('提示', '你没有选中行');
                }
                var record = store3.getAt(cell[0]);
                //删除的订单号放入array
                if(''!= record.get('detailno') && '自动生成' != record.get('detailno')){
                    delArray.push(record.get('detailno'));
                }
                store3.remove(record);
            }
        }, {
            text: '保存',
            iconCls: 'acceptIcon',
            handler: function(){
                saveRow3();
            }
        },'-',{
            text:'合计',
            xtype: 'button',
            id: 'totalmoney',
            name: 'totalmoney',
            handleMouseEvents :false,
            emptyText: '订单合计数量',
            readOnly:true,
            width: 100,
        },'->',{
            text: '审核',
            id: 'tbi_auid',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                auid('1');
            }
        },{
            text: '驳回',
            id: 'tbi_bh',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                auid('2');
            }
        },{
            text: '完成',
            id: 'tbi_wc',
            iconCls: 'edit1Icon',
            disabled: true,
            handler: function(){
                auid('3');
            }
        }]
    });
    
    // 表格实例
    var grid3 = new Ext.grid.EditorGridPanel({
        // 表格面板标题,默认为粗体，我不喜欢粗体，这里设置样式将其格式为正常字体
        title: '<span class="commoncss">订单明细</span>',
        height: 500,
        id: 'id_grid_grid2',
        autoScroll: true,
        //columnWidth: .90,
        frame: true,
        region: 'center', // 和VIEWPORT布局模型对应，充当center区域布局
        store: store3, // 数据存储
        //stripeRows : true, // 斑马线
        cm: cm3, // 列模型
        tbar: tbar3, // 表格工具栏
        //bbar : bbar2,// 分页工具栏 
        clicksToEdit: 1, // 单击、双击进入编辑状态
        viewConfig: {
            // 不产横向生滚动条, 各列自动扩展自动压缩, 适用于列数比较少的情况
            forceFit: false
        },
        loadMask: {
            msg: '正在加载表格数据,请稍等...'
        }
    });
    
    
    // 页面初始自动查询数据
    //store2.load();
    
    // 布局模型
    // var viewport = new Ext.Viewport({
        // layout: 'border',
        // items: [myForm, grid2]
    // });
    
    // 查询表格数据
    function queryCatalogItem(){
        store3.load({
            params: {
                start: 0,
                //limit : bbar2.pageSize,
                orderno: Ext.getCmp('ordernos').getValue()
            }
        });
    }
    
    //合计金额
    function countAll(){
         var m = store3.sum('totalprice');
         //alert(m);
         Ext.getCmp('totalmoney').setText('合计：'+m);
    }
    
    
    
    // 保存
    function saveRow3(){
        var m = store3.modified.slice(0); // 获取修改过的record数组对象
        //if (Ext.isEmpty(m)) {
         //   Ext.MessageBox.alert('提示', '没有数据需要保存!');
         //   return;
        //}
        if (!validateEditGrid(m, 'goodno')) {
            Ext.Msg.alert('提示', '商品号名称字段数据校验不合法,请重新输入!', function(){
                grid3.startEditing(0, 2);
            });
            return;
        }
        if (!validateEditGrid(m, 'ordernum')) {
                    Ext.Msg.alert('提示', '订单数量不合法,请重新输入!', function() {
                                grid3.startEditing(0, 7);
                            });
                    return;
         }
        var jsonArray = [];
        // 将record数组对象转换为简单Json数组对象
        Ext.each(m, function(item){
            jsonArray.push(item.data);
        });
        //alert(Ext.encode(delArray));
       // return;
        // 提交到后台处理
        Ext.Ajax.request({
            url: 'order.ered?reqCode=saveOrder',
            success: function(response){ // 回调函数有1个参数
                var resultArray = Ext.util.JSON.decode(response.responseText);
                Ext.getCmp('ordernos').setValue(resultArray['ordernos']);
                Ext.Msg.alert('提示', resultArray['result']);
                 store3.load({
                    params: {
                        start: 0,
                        //limit : bbar2.pageSize,
                        ordernos: Ext.getCmp('updateno').getValue()
                    }
                });
            },
            failure: function(response){
                Ext.MessageBox.alert('提示', '数据保存失败');
            },
            params: {
                
                ordernos: Ext.getCmp('updateno').getValue(),
                deldata : Ext.encode(delArray),
                detailData: Ext.encode(jsonArray)
            }
        });
    }
    
    // 检查新增行的可编辑单元格数据合法性
    function validateEditGrid(m, colName){
        for (var i = 0; i < m.length; i++) {
            var record = m[i];
            var rowIndex = store3.indexOfId(record.id);
            var value = record.get(colName);
            if (Ext.isEmpty(value)) {
                // Ext.Msg.alert('提示', '数据校验不合法');
                return false;
            }
            var colIndex = cm3.findColumnIndex(colName);
            var editor = cm3.getCellEditor(colIndex).field;
            if (!editor.validateValue(value)) {
                // Ext.Msg.alert('提示', '数据校验不合法');
                return false;
            }
        }
        return true;
    }
    
    /**
     * 添加物品新界面
     */
   var updateWindow = new Ext.Window({
        title: '<span class="commoncss">录入产品信息<span>', // 窗口标题
        layout: 'fit', // 设置窗口布局模式
        width: 800, // 窗口宽度
        height: 440, // 窗口高度
        closable: false, // 是否可关闭
        collapsible: true, // 是否可收缩
        maximizable: true, // 设置是否可以最大化
        border: false, // 边框线设置
        constrain: true, // 设置窗口是否可以溢出父容器
        autoScroll: true,
        animateTarget: Ext.getBody(),
        pageY: 20, // 页面定位Y坐标
        pageX: document.body.clientWidth / 2 - 800 / 2, // 页面定位X坐标
        items: [updateForm,grid3], // 嵌入的表单面板
        buttons: [ {
            text: '重置',
            iconCls: 'tbar_synchronizeIcon',
            handler: function(){
                updateForm.getForm().reset();
            }
        }, {
            text: '关闭',
            iconCls: 'deleteIcon',
            handler: function(){
                updateWindow.hide();
                queryOrderDatas();
            }
        }]
    });
    /**
     * 修改项目
     */
    function updateCatalogItem(){
        var record = grid.getSelectionModel().getSelected();
        if (Ext.isEmpty(record)) {
            Ext.Msg.alert('提示:', '请先选中项目');
            return;
        }
        //alert(record.get('ordernos'));
        store3.load({
            params: {
                start: 0,
                ordernos: record.get('ordernos')
            }
        });
        
        delArray = [];
        updateForm.getForm().loadRecord(record);
        updateWindow.show(); // 显示窗口
    }
    
    //type 1 审核 （原状态在0/2）
    //type 2 驳回（需要原状态在1）
    //type 3 教委审核需要原状态在1）
    //type 4 删除 （原状态在0/2）
    function auid(type){
        var record = grid.getSelectionModel().getSelected();
        if (Ext.isEmpty(record)) {
            Ext.Msg.alert('提示:', '请先选中项目');
            return;
        }else{
            if(type == 1){
                if(record.get('operstatus') !=0 && record.get('operstatus') !=2){
                    Ext.Msg.alert('提示:', '订单新建或驳回状态才能审核！');
                    return ;
                }
            }else  if(type == 2){
                if(record.get('operstatus') !=1){
                    Ext.Msg.alert('提示:', '订单需要提交申请才能驳回！');
                    return ;
                }
            }else  if(type == 3){
                if(record.get('operstatus') !=1 ){
                    Ext.Msg.alert('提示:', '订单需要提交申请才能完成！');
                    return ;
                }
            }else if(type == 4){
                if(record.get('operstatus') !=0 && record.get('operstatus') !=2){
                    Ext.Msg.alert('提示:', '订单新建或驳回状态才能删除！');
                    return ;
                }
            }
        }
       // return ;
        // 提交到后台处理
        Ext.Ajax.request({
            url: 'order.ered?reqCode=operOrder',
            success: function(response){ // 回调函数有1个参数
                 var resultArray = Ext.util.JSON.decode(response.responseText);
                Ext.Msg.alert('提示', resultArray['result']);
                //queryOrderDatas();
            },
            failure: function(response){
               // alert(2);
                Ext.MessageBox.alert('提示', '数据操作失败');
            },
            params: {
                // 系列化为Json资料格式传入后台处理
                ordernos: record.get('ordernos'),
                operType : type
            }
        });
        
       
    }
    
    
    //************************************************************
});
